《Java语言程序设计》期末试卷A (精选03)

注意：

（1）所有答案均写在答题纸上，写在试卷上无效；（2）试题中若出现Java源代码，则不考虑源代码的大小写错误和标点符号错误，也不考虑标点符号的中英文状态；但考生自己书写的代码需要注意大小写！（3）当题目中只有程序片段时，假设完整程序已经具有其它必要代码并导入 Java 的必需包、主类的定义、main()方法的定义等。（4）考试结束，试卷和答题纸一起上交。

一、单选题(每题 2 分,共 30 分)

1、以下哪个不是 Java 的原始数据类型（）

A. int
B. double
C. byte
D. String

查看答案与解析

答案：D

解析： Java 的 8 种原始（基本）数据类型：byte, short, int, long, float, double, char, boolean。String 是引用类型（类类型），不是原始数据类型。

难度: ⭐ 考点: #基本数据类型 #引用类型

💡 学习锦囊

📖 相关公式与知识点:

8 种基本类型：byte, short, int, long, float, double, char, boolean。
引用类型：String、数组、类对象等。

易错点

String 是引用类型，不是原始类型。

🔄 举一反三

判断：char 是 Java 的原始数据类型。（）
查看练习答案与解析
答案：√ 解析：char 是 Java 的 8 种基本数据类型之一。

2、如下字符串可用作 Java 变量名的是（）

A. _sysValue
B. class
C. 3number
D. #number

查看答案与解析

答案：A

解析：

A：_sysValue 以下划线开头，由字母和下划线组成，合法。✓
B：class 是 Java 关键字，不能用作变量名。✗
C：3number 以数字开头，不合法。✗
D：#number 包含 #，不合法。✗

难度: ⭐ 考点: #标识符 #关键字

💡 学习锦囊

📖 相关公式与知识点:

标识符规则：字母/下划线/美元符号开头，不含 #、不以数字开头，不能使用关键字。

易错点

class 是关键字，不能用作变量名。

🔄 举一反三

判断：_（单个下划线）是 Java 中合法的标识符。（）
查看练习答案与解析
答案：√ 解析：单个下划线 _ 是合法的 Java 标识符。

3、能够判断 char 型变量 c 为数字的表达式是（）

A. '9' >= c >= '0'
B. c >= '0' && c <= '9'
C. 9 >= c || c >= 0
D. 9 >= c >= 0

查看答案与解析

答案：B

解析：

A：Java 不支持连续比较 '9' >= c >= '0'。✗
B：c >= '0' && c <= '9'，正确判断数字字符。✓
C：9 >= c || c >= 0 逻辑错误，用了 || 且比较的是数字而非字符。✗
D：同 A，不支持连续比较。✗

难度: ⭐ 考点: #字符比较 #逻辑运算符

💡 学习锦囊

📖 相关公式与知识点:

数字字符范围：'0' ~ '9'，对应 Unicode 编码 48~57。
Java 不支持连续比较：a >= c >= b 是非法语法。

易错点

Java 不支持连续比较，必须用 && 连接两个比较。

🔄 举一反三

判断 char 型变量 c 为大写字母的正确表达式是什么？
查看练习答案与解析
答案：c >= 'A' && c <= 'Z'解析：大写字母的范围是 'A'(65) ~ 'Z'(90)。

4、若整型变量 i 的值为偶数，那么值为 true 的逻辑表达式是（）

A. i / 2 == 0;
B. i % 2 != 1;
C. i % 2 == 1;
D. i % 2 equals 0;

查看答案与解析

答案：B

解析：

A：i / 2 == 0 是整数除法，只有 i 为 0 或 1 时才为 true，不正确。
B：i % 2 != 1，偶数除以 2 余 0（不等于 1），为 true。✓
C：i % 2 == 1，偶数除以 2 余 0（不等于 1），为 false，不正确。
D：equals 是对象方法，不能用于 int 的比较。

难度: ⭐ 考点: #取模运算 #偶数判断

💡 学习锦囊

📖 相关公式与知识点:

判断偶数：i % 2 == 0 或 i % 2 != 1。

易错点

i / 2 == 0 不是判断偶数的正确方式（整数除法问题）。

🔄 举一反三

判断负数 -4 是否为偶数，-4 % 2 == 0 的结果是什么？
查看练习答案与解析
答案：true 解析：Java 中 -4 % 2 = 0，所以 -4 % 2 == 0 为 true。

5、设有定义 int x; float y; 则下列表达式中结果为整型的是（）

A. (float)y + x
B. (int)x + y
C. (int)y + x
D. (float)x + y

查看答案与解析

答案：C

解析：

A：(float)y + x，float + int → float，结果为浮点型。✗
B：(int)x + y，int + float → float，结果为浮点型。✗
C：(int)y + x，先将 y 强转为 int，int + int → int，结果为整型。✓
D：(float)x + y，float + float → float，结果为浮点型。✗

难度: ⭐ 考点: #类型转换 #自动类型提升

💡 学习锦囊

📖 相关公式与知识点:

自动类型提升：int + float → float，小范围自动提升为大范围。
强制类型转换：(int)y 将 float 转为 int，截断小数部分。

易错点

(int)y + x 是先强转 y 再加 x，结果为 int；(int)(y + x) 是先加再强转。

🔄 举一反三

double d = 5.9; int a = (int)d; a 的值是多少？
查看练习答案与解析
答案：5 解析：强制类型转换截断小数部分，5.9 → 5。

6、语句 { int x = 3; int y = 2; y = ++x; } 执行后，x、y 的值分别为（）

A. 4, 4
B. 4, 3
C. 3, 3
D. 3, 2

查看答案与解析

答案：A

解析：y = ++x 是前缀自增，先将 x 自增为 4，再将 4 赋值给 y。所以 x = 4, y = 4。

注意区分 ++x（前缀：先增后用）和 x++（后缀：先用后增）：

y = ++x：x 先变为 4，y = 4
y = x++：y = 3，x 后变为 4

难度: ⭐ 考点: #自增运算符

💡 学习锦囊

📖 相关公式与知识点:

前缀自增：++x，先增后用。
后缀自增：x++，先用后增。

易错点

++x 与 x++ 在赋值时结果不同。

🔄 举一反三

设 int x = 5; int y = x++; 执行后 x 和 y 的值分别是多少？
查看练习答案与解析
答案：x=6, y=5 解析：x++ 是后缀自增，先将 x 的值 5 赋给 y，然后 x 自增为 6。

7、下列程序段：

java

boolean a = false, b = true;
boolean c = (a && b) && (!b);
boolean result = (a || b) && (!b);

执行完后，正确的结果是（）

A. c=false; result=false
B. c=true; result=true
C. c=true; result=false
D. c=false; result=true

查看答案与解析

答案：A

解析：

a = false, b = true
c = (a && b) && (!b) = (false && true) && (!true) = false && false = false
result = (a || b) && (!b) = (false || true) && (!true) = true && false = false

因此 c=false, result=false，选 A。

难度: ⭐ 考点: #逻辑运算符 #短路求值

💡 学习锦囊

📖 相关公式与知识点:

逻辑运算符：&&（与）、||（或）、!（非）。
短路求值：&& 遇到 false 则不再计算右边；|| 遇到 true 则不再计算右边。

易错点

&& 和 || 具有短路特性，& 和 | 没有。

🔄 举一反三

boolean x = true || (5/0 > 0); 会抛出异常吗？
查看练习答案与解析
答案：不会解析：|| 具有短路特性，左边 true 则不再计算右边。

8、设有定义：int[] a = {4, 2, -7, 5, 1, 6, 3}; 则 a[a[4]] 的值为（）

A. 4
B. 2
C. -7
D. 5

查看答案与解析

答案：B

解析： 数组 a = {4, 2, -7, 5, 1, 6, 3}，索引从 0 开始：

a[4] = 1
a[a[4]] = a[1] = 2

难度: ⭐ 考点: #数组索引

💡 学习锦囊

📖 相关公式与知识点:

数组索引：从 0 开始，a.length 为数组长度。
嵌套索引：a[a[i]] 先计算内层索引，再取值。

易错点

数组索引从 0 开始，a[4] 是第 5 个元素。

🔄 举一反三

设 int[] a = {10, 20, 30, 40, 50}; 求 a[a[0]/10] 的值。
查看练习答案与解析
答案：20 解析：a[0] = 10，10/10 = 1，a[1] = 20。

9、对于一个三位正整数 n，表达式（）可以取出 n 的十位数字。

A. n % 10 / 10
B. n % 10
C. n / 10 % 10
D. n / 10

查看答案与解析

答案：C

解析： 以 n = 123 为例：

A：123 % 10 / 10 = 3 / 10 = 0 ✗
B：123 % 10 = 3（个位）✗
C：123 / 10 % 10 = 12 % 10 = 2 ✓
D：123 / 10 = 12 ✗

难度: ⭐ 考点: #取位运算

💡 学习锦囊

📖 相关公式与知识点:

取位运算：个位 n%10，十位 n/10%10，百位 n/100%10。

易错点

取十位是先除以 10 再取模 10，不是先取模再除。

🔄 举一反三

取出一个五位正整数 n 的百位数字，表达式是什么？
查看练习答案与解析
答案：n / 100 % 10解析：以 n = 12345 为例，12345 / 100 = 123，123 % 10 = 3，即百位数字。

10、下列各语句序列中，能够将变量 u、s 中最大值赋值到变量 t 中的是（）

A. if (u > s) t = u; t = s;
B. t = s; if (u > s) t = u;
C. if (u > s) t = s; else t = u;
D. t = u; if (u > s) t = s;

查看答案与解析

答案：B

解析：

A：if(u>s) t=u; 后面 t=s; 无条件执行，t 总是等于 s。✗
B：先 t=s，若 u>s 则 t=u，最终 t 为较大值。✓
C：若 u>s 则 t=s（错误，应赋 u），否则 t=u。逻辑反了。✗
D：先 t=u，若 u>s 则 t=s（错误）。✗

难度: ⭐ 考点: #if语句 #求最大值

💡 学习锦囊

📖 相关公式与知识点:

求最大值：先假设一个值为最大，再与另一个比较，更大则更新。

易错点

注意 if 后面没有大括号时，只控制一条语句。

🔄 举一反三

用三元运算符实现 t = max(u, s)。
查看练习答案与解析
答案：t = (u > s) ? u : s;解析：如果 u > s，返回 u；否则返回 s。

11、有一个类 B，下面为其构造方法的声明，正确的是（）

A. void A(int x){}
B. B(int x){}
C. void C(float x){}
D. D(float x){}

查看答案与解析

答案：B

解析： 构造方法的规则：

方法名必须与类名相同
没有返回类型（连 void 也没有）
A：方法名 A 与类名 B 不同，且有 void 返回类型。✗
B：方法名 B 与类名相同，无返回类型。✓
C：方法名 C 与类名 B 不同，且有 void 返回类型。✗
D：方法名 D 与类名 B 不同。✗

难度: ⭐ 考点: #构造方法

💡 学习锦囊

📖 相关公式与知识点:

构造方法：与类同名，无返回类型（连 void 也没有），用于初始化对象。

易错点

构造方法没有返回类型，连 void 都不能写。

🔄 举一反三

判断：构造方法可以被 static 修饰。（）
查看练习答案与解析
答案：× 解析：构造方法不能被 static 修饰，它属于对象级别而非类级别。

12、为 B 类定义一个静态的、无返回值的方法 f，该方法头的形式为（）

A. protected void f()
B. public void f()
C. private void f()
D. static void f()

查看答案与解析

答案：D

解析： 题目要求"静态的、无返回值的方法"：

静态 → 需要 static 修饰符
无返回值 → void
A/B/C 都缺少 static 修饰符。✗
D：static void f() 满足要求。✓

难度: ⭐ 考点: #static #方法声明

💡 学习锦囊

📖 相关公式与知识点:

static 方法：属于类，通过类名调用，不需要创建对象。
实例方法：属于对象，需要通过对象调用。

易错点

静态方法不能直接访问非静态成员。

🔄 举一反三

判断：静态方法中可以使用 this 关键字。（）
查看练习答案与解析
答案：× 解析：静态方法属于类，不依赖对象，因此不能使用 this。

13、下面哪个方法可以作为 public void example(){...} 的重载方法？（）

A. public int Example(int m){...}
B. private void example(){...}
C. private int Example2(double m){...}
D. public void example(int m, float f){...}

查看答案与解析

答案：D

解析： 重载（Overload）要求：方法名相同，参数列表不同（类型、个数、顺序不同），与返回类型和访问修饰符无关。

A：方法名 Example 与 example 不同（大小写不同），不是重载。✗
B：参数列表相同（无参数），仅访问修饰符不同，不是重载。✗
C：方法名 Example2 不同，不是重载。✗
D：方法名 example 相同，参数为 (int m, float f) 与原方法 () 不同，是合法重载。✓

难度: ⭐ 考点: #方法重载

💡 学习锦囊

📖 相关公式与知识点:

方法重载：同名不同参（类型、个数、顺序），与返回类型无关。

易错点

方法重载只看参数列表，返回类型不同不算重载。
Java 区分大小写，Example 和 example 是不同的方法名。

🔄 举一反三

以下哪个是 public int compute(double x){...} 的合法重载？
- A. public int compute(double y){...}
- B. public double compute(double x){...}
- C. public int compute(int x){...}
- D. public int Compute(double x){...}
查看练习答案与解析
答案：C 解析：重载要求参数列表不同。A 参数类型相同；B 返回类型不同但参数相同；C 参数类型从 double 变为 int，是合法重载；D 方法名不同。

14、在 Java 中，关于捕获异常的语法 try-catch-finally 的下列描述正确的是（）

A. try-catch 必须配对使用
B. try 可以单独使用
C. try-finally 必须配对使用
D. 在 try-catch 后如果定义了 finally，则 finally 肯定会执行

查看答案与解析

答案：D

解析：

A 错误：try-catch 不是必须配对，try 可以和 finally 配合使用。
B 错误：try 不能单独使用，必须配合 catch 或 finally。
C 错误：try-finally 不是必须配对，try 也可以和 catch 配合。
D 正确：finally 块总是执行（除非 JVM 退出或调用 System.exit()），无论是否发生异常。✓

难度: ⭐ 考点: #异常处理 #try-catch-finally

💡 学习锦囊

📖 相关公式与知识点:

try-catch-finally：try 必须配合 catch 或 finally 使用。
finally：总是执行（除非 System.exit()）。

易错点

try 不能单独使用，必须配合 catch 或 finally。
finally 块总是会执行，即使 try 中有 return。

🔄 举一反三

判断：try 块可以单独使用，不需要 catch 或 finally。（）
查看练习答案与解析
答案：× 解析：try 必须配合 catch 或 finally 使用，不能单独存在。

15、为了以字符方式从文件读出内容，可以使用（）类。

A. java.io.FileReader
B. java.io.FileInputStream
C. java.io.FileOutputStream
D. java.io.FileWriter

查看答案与解析

答案：A

解析：

A：FileReader 是字符输入流，以字符方式读取文件。✓
B：FileInputStream 是字节输入流，以字节方式读取。✗
C：FileOutputStream 是字节输出流。✗
D：FileWriter 是字符输出流，用于写入。✗

难度: ⭐ 考点: #字符流 #字节流

💡 学习锦囊

📖 相关公式与知识点:

字节流 vs 字符流：InputStream/OutputStream（字节），Reader/Writer（字符）。

易错点

FileReader 是字符输入流，FileInputStream 是字节输入流。

🔄 举一反三

以字节方式写入文件应使用哪个类？
查看练习答案与解析
答案：FileOutputStream 解析：FileOutputStream 是字节输出流，用于以字节方式写入文件。

二、程序阅读题(每题 5 分,共 20 分)

1、有如下程序：

java

public class abc {
    public static void main(String args[]) {
        int i, s = 0;
        int a[] = {10, 20, 30, 40, 50, 60, 70, 80, 90};
        for (i = 0; i < a.length; i++)
            if (a[i] % 3 == 0)
                s = s + a[i];
        System.out.println("s=" + s);
    }
}

输出结果是 (1)

查看答案与解析

答案：s=180

解析： 遍历数组 {10, 20, 30, 40, 50, 60, 70, 80, 90}，找出能被 3 整除的元素并累加：

10 % 3 = 1 ✗
20 % 3 = 2 ✗
30 % 3 = 0 ✓ → s = 30
40 % 3 = 1 ✗
50 % 3 = 2 ✗
60 % 3 = 0 ✓ → s = 90
70 % 3 = 1 ✗
80 % 3 = 2 ✗
90 % 3 = 0 ✓ → s = 180

输出 s=180。

难度: ⭐⭐ 考点: #数组遍历 #取模运算

💡 学习锦囊

📖 相关公式与知识点:

数组遍历：a.length 获取数组长度，从 0 开始索引。
取模运算：n % 3 == 0 判断能否被 3 整除。

易错点

注意数组索引从 0 开始。

🔄 举一反三

以下程序输出什么？

java

int[] a = {5, 10, 15, 20, 25};
int s = 0;
for (int i = 0; i < a.length; i++)
    if (a[i] % 2 == 0) s += a[i];
System.out.println(s);

查看练习答案与解析

答案：30 解析：遍历数组，累加偶数元素：10 + 20 = 30。

2、有如下程序：

java

public class test {
    public static void main(String[] args) {
        int i = 6;
        do {
            System.out.print(i);
        } while (--i >= 5);
        System.out.println("6");
    }
}

输出结果是 (2)

查看答案与解析

答案：656

解析： do-while 循环执行过程：

i=6：输出 "6"，--i → i=5，5>=5 为 true，继续
i=5：输出 "5"，--i → i=4，4>=5 为 false，退出循环
循环后输出 "6"

最终输出 656。

难度: ⭐⭐ 考点: #do-while循环 #前缀自减

💡 学习锦囊

📖 相关公式与知识点:

do-while 循环：先执行后判断，至少执行一次。
--i：前缀自减，先减后用。

易错点

do-while 至少执行一次，与 while 不同。
--i 是前缀自减，先减后用；i-- 是后缀自减，先用后减。

🔄 举一反三

若将 --i 改为 i--，程序输出什么？
查看练习答案与解析
答案：65432106 解析：i-- 是后缀自减，先使用 i 的值再减。循环：i=6 输出6，判断 6>=5 true，i 变 5；i=5 输出5，判断 5>=5 true，i 变 4；...直到 i=0 输出0，判断 0>=5 false 退出。输出 65432106。

3、有如下程序：

java

class abc {
    public static void main(String[] args) {
        int b = 1;
        modify(b + 1);
        System.out.println("b=" + b);
    }
    public static void modify(int b) {
        b++;
    }
}

输出结果是 (3)

查看答案与解析

答案：b=1

解析： Java 中基本类型是值传递：

b = 1
调用 modify(b + 1)：先计算 b + 1 = 2，将 2 传给 modify 的参数 b
modify 中 b++ 使局部变量 b 变为 3，但不影响 main 中的 b
main 中的 b 仍然是 1

输出 b=1。

难度: ⭐⭐ 考点: #值传递

💡 学习锦囊

📖 相关公式与知识点:

值传递：Java 基本类型传值，方法内修改不影响实参。

易错点

Java 只有值传递，没有引用传递。

🔄 举一反三

若将 modify 的参数改为数组 modify(int[] arr)，在方法内修改 arr[0] = 100，会影响原数组吗？
查看练习答案与解析
答案：会解析：数组是引用类型，传递的是引用的副本，但指向同一个数组对象，修改数组元素会影响原数组。

4、有如下程序：

java

public class abc {
    public static void main(String args[]) {
        AB s = new AB("Hello!", "I love JAVA.");
        System.out.println(s.toString());
    }
}
class AB {
    String s1;
    String s2;
    public AB(String str1, String str2) {
        s1 = str1;
        s2 = str2;
    }
    public String toString() {
        return s1 + " " + s2;
    }
}

输出结果是 (4)

查看答案与解析

答案：Hello! I love JAVA.

解析：

创建 AB 对象，s1 = "Hello!", s2 = "I love JAVA."
调用 toString() 方法，返回 s1 + " " + s2 = "Hello! I love JAVA."

难度: ⭐⭐ 考点: #toString方法 #字符串拼接

💡 学习锦囊

📖 相关公式与知识点:

toString()：Object 类的方法，子类可重写以返回对象的字符串表示。
字符串拼接：+ 运算符用于字符串拼接。

易错点

System.out.println(s) 会自动调用 s.toString()。

🔄 举一反三

若不重写 toString()，System.out.println(s) 输出什么？
查看练习答案与解析
答案：类名@哈希码（如 AB@15db9742）解析：Object 的默认 toString() 返回 类名@哈希码。

5、有如下程序：

java

class Employee {
    String name;
    Employee(String name) {
        this.name = name;
    }
    void show() {
        System.out.println(name + " is a Employee");
    }
}
class Manager extends Employee {
    Manager(String name) {
        super(name);
    }
    void show() {
        System.out.println(name + " is a Manager");
    }
}
public class test {
    public static void main(String args[]) {
        Employee e1 = new Employee("Tom");
        Employee e2 = new Manager("John");
        e1.show();
        e2.show();
    }
}

输出结果是 (5)

查看答案与解析

答案：

Tom is a Employee
John is a Manager

解析：

e1 = new Employee("Tom")：e1 是 Employee 对象，调用 Employee 的 show()，输出 "Tom is a Employee"
e2 = new Manager("John")：e2 声明为 Employee 类型，但实际指向 Manager 对象。由于 多态（动态绑定），调用的是 Manager 重写后的 show()，输出 "John is a Manager"

这是 Java 多态的经典体现：编译看左边，运行看右边。

难度: ⭐⭐ 考点: #多态 #动态绑定 #方法重写

💡 学习锦囊

📖 相关公式与知识点:

多态：父类引用指向子类对象时，调用被重写的方法会执行子类版本。
动态绑定：运行时根据实际对象类型决定调用哪个方法。

易错点

多态中方法调用看实际对象类型，不是引用类型。

🔄 举一反三

以下程序输出什么？

java

class Animal {
    void sound() { System.out.print("Animal sound "); }
}
class Dog extends Animal {
    void sound() { System.out.print("Woof "); }
}
Animal a = new Dog();
a.sound();

查看练习答案与解析

答案：Woof 解析：多态——a 声明为 Animal 但实际是 Dog 对象，调用 Dog 重写的 sound() 方法。

三、程序填空题(每空 2 分,共 20 分)

程序 1： 如下程序计算斐波拉切(Fibonacci)数列的第 10 项。已知该数列的前两项都为 1，即 F(1) = F(2) = 1；而后面各项满足：F(n) = F(n-1) + F(n-2)。

java

class Hello {
    public static void main(String[] args) {
        int f10 = fib(10);
        System.out.println(f10);
    }
    static long fib(int k) {
        if ( (1) )
            return 1;
        else
            return (2);
    }
}

查看答案与解析

答案：

(1) k == 1 || k == 2
(2) fib(k - 1) + fib(k - 2)

解析：

(1) 递归终止条件：F(1) = F(2) = 1，当 k 为 1 或 2 时返回 1。
(2) 递归关系：F(n) = F(n-1) + F(n-2)，调用自身计算前两项之和。

难度: ⭐⭐⭐ 考点: #递归 #斐波那契数列

💡 学习锦囊

📖 相关公式与知识点:

斐波那契数列：F(1)=F(2)=1, F(n)=F(n-1)+F(n-2)。递归实现简洁但效率低（O(2^n)），迭代实现效率高（O(n)）。
递归三要素：终止条件、递归关系、自身调用。

易错点

递归必须有终止条件，否则会栈溢出。

🔄 举一反三

用迭代方式实现斐波那契数列第 n 项。

查看练习答案与解析

java

static long fibIter(int n) {
    if (n <= 2) return 1;
    long a = 1, b = 1, c = 0;
    for (int i = 3; i <= n; i++) {
        c = a + b;
        a = b;
        b = c;
    }
    return c;
}

解析：迭代方式只需 O(n) 时间和 O(1) 空间，远优于递归的 O(2^n)。

程序 2： 有二分查找程序如下：

java

class biSearch {
    public static void main(String[] args) {
        int a[] = {9, 13, 25, 34, 38, 62, 69, 78, 86, 97};
        int searchnum = 86;
        int index = -1, left, mid, right;
        left = 0;
        right = a.length - 1;
        while (left <= right) {
            mid = (3);
            if (a[mid] == searchnum) {
                index = mid;
                break;
            } else if (a[mid] < searchnum) {
                (4);
            } else {
                (5);
            }
        }
        if (index == -1)
            System.out.println(searchnum + "在数组中不存在!");
        else
            System.out.println(searchnum + "在数组中位置是" + index);
    }
}

查看答案与解析

答案：

(3) (left + right) / 2
(4) left = mid + 1
(5) right = mid - 1

解析：

(3) 二分查找取中间位置：mid = (left + right) / 2。
(4) 若中间元素小于目标值，说明目标在右半段，left = mid + 1。
(5) 若中间元素大于目标值，说明目标在左半段，right = mid - 1。

难度: ⭐⭐⭐ 考点: #二分查找

💡 学习锦囊

📖 相关公式与知识点:

二分查找：前提是数组有序。每次比较中间元素，缩小一半搜索范围。时间复杂度 O(log n)。

易错点

left = mid + 1 和 right = mid - 1，不能写成 left = mid 或 right = mid，否则可能死循环。

🔄 举一反三

在有序数组 {2, 5, 8, 12, 16, 23, 38, 56, 72, 91} 中用二分查找 23，写出查找过程。
查看练习答案与解析
答案：找到，索引为 5 解析：
- left=0, right=9, mid=4, a[4]=16 < 23, left=5
- left=5, right=9, mid=7, a[7]=56 > 23, right=6
- left=5, right=6, mid=5, a[5]=23 == 23, 找到！

程序 3： 有冒泡排序程序如下：

java

class maopao {
    public static void main(String[] args) {
        int a[] = {37, 28, 51, 13, 64, 8, 42};
        int i, j, n, temp;
        n = a.length;
        for (j = 1; (6); j++) {
            for (i = 0; (7); i++) {
                if (a[i] > a[i + 1]) {
                    temp = a[i];
                    (8);
                    a[i + 1] = temp;
                }
            }
        }
        System.out.print("排序后的数据为：");
        for (i = 0; i < n; i++)
            System.out.print(a[i] + " ");
    }
}

查看答案与解析

答案：

(6) j < n（或 j < a.length）
(7) i < n - j（或 i < a.length - j）
(8) a[i] = a[i + 1]

解析：

(6) 外层循环控制排序趟数，共需 n-1 趟，j < n 即可。
(7) 内层循环控制每趟比较次数，第 j 趟比较 n-j 次，i < n - j。
(8) 交换两个相邻元素：a[i] = a[i + 1]，配合前后的 temp 赋值完成交换。

难度: ⭐⭐⭐ 考点: #冒泡排序

💡 学习锦囊

📖 相关公式与知识点:

冒泡排序：相邻元素两两比较，每趟将最大值"冒泡"到末尾。时间复杂度 O(n²)。

易错点

冒泡排序内层循环范围 i < n - j，不是 i < n - 1（虽然第一趟等价）。

🔄 举一反三

冒泡排序对数组 {5, 3, 8, 1} 第一趟排序后的结果是什么？
查看练习答案与解析
答案：{3, 5, 1, 8}解析：比较 5>3 交换→{3,5,8,1}，5<8 不交换，8>1 交换→{3,5,1,8}。8 冒泡到末尾。

程序 4： 本程序定义了一个描述时间的 Time 类，程序运行输出为 15:50:18。

java

import java.io.*;
class Time {
    private int hour, minute, second;
    (9)(int h, int m, int s) {
        hour = h;
        minute = m;
        second = s;
    }
    void setHour(int hour) {
        (10);
    }
    public String toString() {
        return hour + ":" + minute + ":" + second;
    }
    public static void main(String args[]) {
        Time aTime = new Time(23, 50, 18);
        aTime.setHour(15);
        System.out.print(aTime.toString());
    }
}

查看答案与解析

答案：

(9) Time
(10) this.hour = hour

解析：

(9) 构造方法名必须与类名相同，所以填 Time。
(10) 参数 hour 与成员变量 hour 同名，需用 this.hour 区分，this.hour = hour 将参数值赋给成员变量。

难度: ⭐⭐ 考点: #构造方法 #this关键字

💡 学习锦囊

📖 相关公式与知识点:

构造方法：与类同名，无返回类型，用于初始化对象。
this 关键字：区分成员变量与局部变量同名时的歧义，this.变量名 指代成员变量。

易错点

this.hour = hour 中 this 不可省略，否则变成自赋值。

🔄 举一反三

若 setHour 方法改为 void setHour(int h)，方法体应如何写？
查看练习答案与解析
答案：hour = h;解析：参数名 h 与成员变量 hour 不同名，不需要 this，直接赋值即可。

四、程序设计题(每题 10 分,共 30 分)

1、（10分）有一张长方形纸片：从上剪下一个最大的正方形（如长 781cm，宽 123cm），若剩余的还是长方形，再剪下一个最大的正方形，直到剩下的为一正方形为止。问剪出了多少个正方形，边长各是多少。编写程序，打印所剪出的所有正方形的边。

查看答案与解析

答案：

java

public class CutSquare {
    public static void main(String[] args) {
        int length = 781, width = 123;
        int count = 0;
        while (length != width) {
            int side = width < length ? width : length;
            System.out.println("正方形边长：" + side);
            count++;
            if (length > width) {
                length = length - width;
            } else {
                width = width - length;
            }
        }
        System.out.println("正方形边长：" + length);
        count++;
        System.out.println("共剪出 " + count + " 个正方形");
    }
}

运行结果：

正方形边长：123
正方形边长：123
正方形边长：123
正方形边长：123
正方形边长：123
正方形边长：123
正方形边长：43
正方形边长：43
正方形边长：37
正方形边长：6
正方形边长：6
正方形边长：6
正方形边长：6
正方形边长：6
正方形边长：6
正方形边长：1
正方形边长：1
正方形边长：1
正方形边长：1
正方形边长：1
正方形边长：1
共剪出 21 个正方形

解析：

第一步：理解题意 每次从长方形中剪下最大的正方形（边长 = 短边），剩余部分仍为长方形，重复直到剩余为正方形。

第二步：算法分析 这实际上是辗转相减法（欧几里得算法的减法版本），用于求最大公约数：

长边减去短边，得到新的长方形
重复直到两边相等（即为 GCD）

第三步：验证

length=781, width=123：剪 6 个边长 123 的正方形（781-123×6=43）
length=43, width=123：剪 2 个边长 43 的正方形（123-43×2=37）
length=43, width=37：剪 1 个边长 37 的正方形（43-37=6）
length=6, width=37：剪 6 个边长 6 的正方形（37-6×6=1）
length=6, width=1：剪 6 个边长 1 的正方形（6-1×6=0）
最后 1 个边长 1 的正方形
共 6+2+1+6+6 = 21 个

难度: ⭐⭐⭐ 考点: #辗转相减法 #GCD

💡 学习锦囊

📖 相关公式与知识点:

辗转相减法：求 GCD 的减法版本，等价于辗转相除法。GCD(a,b) = GCD(a-b,b)（a>b）。

易错点

辗转相减法中，每次减去短边后要更新正确的变量（长边或短边）。

🔄 举一反三

用辗转相除法求 GCD(781, 123)。
查看练习答案与解析
答案：1 解析：
- 781 ÷ 123 = 6 余 13
- 123 ÷ 13 = 9 余 6
- 13 ÷ 6 = 2 余 1
- 6 ÷ 1 = 6 余 0
- GCD = 1

2、（10分）记载于中国古代约 5—6 世纪成书的《张邱建算经》的一个算术题目：今有鸡翁一，值钱伍；鸡母一，值钱三；鸡鶵三，值钱一。凡百钱买鸡百只，问鸡翁、母、鶵各几何？编写程序，打印出所有答案。

查看答案与解析

答案：

java

public class HundredChickens {
    public static void main(String[] args) {
        for (int x = 0; x <= 20; x++) {
            for (int y = 0; y <= 33; y++) {
                int z = 100 - x - y;
                if (z % 3 == 0 && 5 * x + 3 * y + z / 3 == 100) {
                    System.out.println("鸡翁：" + x + "只，鸡母：" + y + "只，鸡鶵：" + z + "只");
                }
            }
        }
    }
}

运行结果：

鸡翁：0只，鸡母：25只，鸡鶵：75只
鸡翁：4只，鸡母：18只，鸡鶵：78只
鸡翁：8只，鸡母：11只，鸡鶵：81只
鸡翁：12只，鸡母：4只，鸡鶵：84只

解析：

第一步：建立数学模型 设鸡翁 x 只，鸡母 y 只，鸡鶵 z 只：

数量约束：x + y + z = 100
价格约束：5x + 3y + z/3 = 100
非负约束：x ≥ 0, y ≥ 0, z ≥ 0, z 是 3 的倍数

第二步：确定枚举范围

鸡翁：5 钱一只，100 钱最多买 20 只，x ∈ [0, 20]
鸡母：3 钱一只，100 钱最多买 33 只，y ∈ [0, 33]
鸡鶵：z = 100 - x - y，自动确定

第三步：筛选条件

z 必须是 3 的倍数（鸡鶵 3 只 1 钱）
价格等式成立

难度: ⭐⭐⭐ 考点: #枚举法 #不定方程

💡 学习锦囊

📖 相关公式与知识点:

百钱买百鸡：经典不定方程问题，用枚举法（穷举法）求解。
枚举法：遍历所有可能的情况，筛选满足条件的解。适用于解空间较小的问题。

易错点

百钱买百鸡中，z 必须是 3 的倍数，否则 z/3 不是整数。

🔄 举一反三

如果鸡翁改为 7 钱一只，鸡母 5 钱一只，鸡鶵 1 钱三只，百钱买百鸡，如何修改程序？

查看练习答案与解析

修改价格条件和枚举范围：

java

for (int x = 0; x <= 14; x++) {
    for (int y = 0; y <= 20; y++) {
        int z = 100 - x - y;
        if (z % 3 == 0 && 7 * x + 5 * y + z / 3 == 100) {
            System.out.println("鸡翁：" + x + "，鸡母：" + y + "，鸡鶵：" + z);
        }
    }
}

解析：只需修改价格系数和 x 的上限（100/7≈14），y 的上限（100/5=20）。

3、（10分）定义一个实现常用数学运算的类 MyMath，类中有：

三个 int 型成员变量，分别是 x、y、z
一个构造函数，为三个成员变量赋予初值
四个成员函数 max()、min()、sum()与 average()，每个方法带有三个整型参数，分别实现对三个整数求取最大值、最小值、和值及平均值的运算

另外，定义一个测试类 test，在主函数中创建一个 MyMath 类的对象 mh，测试 MyMath 类四个成员函数。

查看答案与解析

答案：

java

class MyMath {
    int x, y, z;

    MyMath(int x, int y, int z) {
        this.x = x;
        this.y = y;
        this.z = z;
    }

    int max(int a, int b, int c) {
        int m = a;
        if (b > m) m = b;
        if (c > m) m = c;
        return m;
    }

    int min(int a, int b, int c) {
        int m = a;
        if (b < m) m = b;
        if (c < m) m = c;
        return m;
    }

    int sum(int a, int b, int c) {
        return a + b + c;
    }

    double average(int a, int b, int c) {
        return (a + b + c) / 3.0;
    }
}

public class test {
    public static void main(String[] args) {
        MyMath mh = new MyMath(10, 20, 30);
        System.out.println("最大值：" + mh.max(10, 20, 30));
        System.out.println("最小值：" + mh.min(10, 20, 30));
        System.out.println("和值：" + mh.sum(10, 20, 30));
        System.out.println("平均值：" + mh.average(10, 20, 30));
    }
}

运行结果：

最大值：30
最小值：10
和值：60
平均值：20.0

解析：

第一步：分析类结构

MyMath 类有 3 个成员变量和 4 个成员方法
构造方法为成员变量赋初值
每个方法带 3 个整型参数进行运算

第二步：实现要点

max()：逐个比较，保留最大值
min()：逐个比较，保留最小值
sum()：直接相加
average()：注意用 3.0 而非 3，避免整数除法

第三步：测试类

创建 MyMath 对象
调用四个方法并输出结果

难度: ⭐⭐⭐ 考点: #类设计 #构造方法 #成员方法 #整数除法

💡 学习锦囊

📖 相关公式与知识点:

类设计原则：成员变量私有化（封装），提供公共方法访问。
整数除法：(a+b+c)/3 结果为整数，(a+b+c)/3.0 结果为浮点数。

易错点

求平均值时要用 3.0 而非 3，避免整数除法丢失小数部分。
类的成员方法如果带参数，参数值可能与成员变量不同，需注意区分。

🔄 举一反三

若 average 方法改为使用成员变量而非参数，方法签名应如何修改？
查看练习答案与解析
答案：double average() { return (x + y + z) / 3.0; }解析：无参数方法直接使用成员变量 x, y, z 计算平均值。

《Java语言程序设计》期末试卷A (精选03) ​

一、单选题(每题 2 分,共 30 分) ​

二、程序阅读题(每题 5 分,共 20 分) ​

三、程序填空题(每空 2 分,共 20 分) ​

四、程序设计题(每题 10 分,共 30 分) ​

《Java语言程序设计》期末试卷A (精选03)

一、单选题(每题 2 分,共 30 分)

二、程序阅读题(每题 5 分,共 20 分)

三、程序填空题(每空 2 分,共 20 分)

四、程序设计题(每题 10 分,共 30 分)